package com.example.demo.utilServcie;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.demo.bean.Funcation;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**
 * 封装了常用的操作Redis的方法工具类
 * 
 * @author Henry
 *
 */
@Service
public class RedisService {

	//注入分片的连接池
	//因为依赖于common的工程,其他工程不一定用到这个redis
	//@Autowired(required = false)就相当于用到才会进行注入的意思
	@Autowired(required = false)
	private ShardedJedisPool shardedJedisPool;

	public <T> T execute(Funcation<T, ShardedJedis> fun) {

		ShardedJedis shardedJedis = null;
		try {
			shardedJedis = shardedJedisPool.getResource();
			return fun.callback(shardedJedis);
		} finally {
			if (null != shardedJedis) {
				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
				shardedJedis.close();
			}
		}
	}

	public String set(final String key, final String value) {

		return this.execute(new Funcation<String, ShardedJedis>() {
			@Override
			public String callback(ShardedJedis e) {
				return e.set(key, value);
			}
		});
	}

	public String get(final String key) {

		return this.execute(new Funcation<String, ShardedJedis>() {
			@Override
			public String callback(ShardedJedis e) {
				return e.get(key);
			}
		});
	}

	/**
	 * Redis的set方法
	 * 
	 * @param key
	 * @param value
	 */
//	public String set(String key,String value){
//	
//        ShardedJedis shardedJedis = null;
//        try {
//            shardedJedis = shardedJedisPool.getResource();
//            return shardedJedis.set(key, value);
//        }finally {
//            if (null != shardedJedis) {
//                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
//                shardedJedis.close();
//            }
//        }
//	}
	/**
	 * Redis的set方法
	 * 
	 * @param key
	 * @param value
	 * @param seconds 生存时间 单位/秒
	 */
	public String setex(String key, Integer seconds, String value) {

		ShardedJedis shardedJedis = null;
		try {
			shardedJedis = shardedJedisPool.getResource();
			return shardedJedis.setex(key, seconds, value);
		} finally {
			if (null != shardedJedis) {
				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
				shardedJedis.close();
			}
		}
	}
	/**
	 * Redis的get方法
	 * 
	 * @param key
	 * @param value
	 */
//	public String get(String key){
//	
//        ShardedJedis shardedJedis = null;
//        try {
//            shardedJedis = shardedJedisPool.getResource();
//            return shardedJedis.get(key);
//        }finally {
//            if (null != shardedJedis) {
//                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
//                shardedJedis.close();
//            }
//        }
//	}

	/**
	 * Redis的设置某个key的生存时间
	 * 
	 * @param key
	 * @param seconds 生存时间 单位/秒
	 */
	public Long expire(String key, Integer seconds) {

		ShardedJedis shardedJedis = null;
		try {
			shardedJedis = shardedJedisPool.getResource();
			return shardedJedis.expire(key, seconds);
		} finally {
			if (null != shardedJedis) {
				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
				shardedJedis.close();
			}
		}
	}

	/**
	 * Redis的del
	 * 
	 * @param key
	 */
	public Long del(String key) {

		ShardedJedis shardedJedis = null;
		try {
			shardedJedis = shardedJedisPool.getResource();
			return shardedJedis.del(key);
		} finally {
			if (null != shardedJedis) {
				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
				shardedJedis.close();
			}
		}
	}

	/**
	 * Redis的del
	 * 
	 * @param key
	 */
	public Long incr(String key) {

		ShardedJedis shardedJedis = null;
		try {
			shardedJedis = shardedJedisPool.getResource();
			return shardedJedis.incr(key);
		} finally {
			if (null != shardedJedis) {
				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
				shardedJedis.close();
			}
		}
	}

}
